Jassif Team Institution

JavaScript Const

const கீவேர்டு ES6 (2015) இல் அறிமுகப்படுத்தப்பட்டது

Cannot be Reassigned

const கீவேர்டுடன் வரையறுக்கப்பட்ட மாறி மீண்டும் ஒதுக்க முடியாது:

const PI = 3.141592653589793;
PI = 3.14;      // ❌ This will give an error
PI = PI + 10;   // ❌ This will also give an error

Must be Assigned

JavaScript const மாறிகள் அறிவிக்கப்படும்போது ஒரு மதிப்பை ஒதுக்க வேண்டும்:

const PI = 3.14159265359;

const PI;  // ❌ Error
PI = 3.14159265359;

When to use JavaScript const?

மதிப்பு மாறக்கூடாது என்று உங்களுக்குத் தெரிந்தால் எப்போதும் ஒரு மாறியை const உடன் அறிவிக்கவும்.

நீங்கள் அறிவிக்கும்போது const பயன்படுத்தவும்:

Constant Objects and Arrays

const கீவேர்டு சிறிது தவறாக புரிந்து கொள்ளப்படுகிறது.

இது ஒரு நிலையான மதிப்பை வரையறுக்காது. இது ஒரு மதிப்புக்கான நிலையான குறிப்பை வரையறுக்கிறது.

Constant Arrays

நீங்கள் ஒரு நிலையான வரிசையின் உறுப்புகளை மாற்றலாம்:

// You can create a constant array:
const cars = ["Saab", "Volvo", "BMW"];

// You can change an element:
cars[0] = "Toyota";  // ✅ Allowed

// You can add an element:
cars.push("Audi");    // ✅ Allowed

ஆனால் நீங்கள் வரிசையை மீண்டும் ஒதுக்க முடியாது:

const cars = ["Saab", "Volvo", "BMW"];

cars = ["Toyota", "Volvo", "Audi"];  // ❌ ERROR

Constant Objects

நீங்கள் ஒரு நிலையான பொருளின் பண்புகளை மாற்றலாம்:

// You can create a const object:
const car = {type:"Fiat", model:"500", color:"white"};

// You can change a property:
car.color = "red";  // ✅ Allowed

// You can add a property:
car.owner = "Johnson";  // ✅ Allowed

ஆனால் நீங்கள் பொருளை மீண்டும் ஒதுக்க முடியாது:

const car = {type:"Fiat", model:"500", color:"white"};

car = {type:"Volvo", model:"EX60", color:"red"};  // ❌ ERROR

Difference Between var, let and const

What is Good?

What is Not Good?

Browser Support

let மற்றும் const கீவேர்டுகள் Internet Explorer 11 அல்லது அதற்கு முந்தைய பதிப்புகளில் ஆதரிக்கப்படவில்லை.

Block Scope

const உடன் ஒரு மாறியை அறிவிப்பது Block Scope பற்றி let போன்றது.

const x = 10;
// Here x is 10

{
  const x = 2;
  // Here x is 2
}

// Here x is 10

Redeclaring Rules

ஒரு JavaScript var மாறியை மீண்டும் அறிவிப்பது ஒரு நிரலில் எங்கும் அனுமதிக்கப்படுகிறது:

var x = 2;     // Allowed
var x = 3;     // Allowed
x = 4;         // Allowed

அதே scope இல் இருக்கும் ஒரு இருக்கும் var அல்லது let மாறியை const ஆக மீண்டும் அறிவிப்பது அனுமதிக்கப்படவில்லை:

var x = 2;     // Allowed
const x = 2;   // ❌ Not allowed

{
  let x = 2;   // Allowed
  const x = 2; // ❌ Not allowed
}

{
  const x = 2; // Allowed
  const x = 2; // ❌ Not allowed
}

மற்றொரு scope இல், அல்லது மற்றொரு தொகுதியில், const உடன் ஒரு மாறியை மீண்டும் அறிவிப்பது அனுமதிக்கப்படுகிறது:

const x = 2;       // Allowed

{
  const x = 3;   // Allowed (different block)
}

{
  const x = 4;   // Allowed (different block)
}

Hoisting

var உடன் வரையறுக்கப்பட்ட மாறிகள் மேலே hoist செய்யப்படுகின்றன மற்றும் எந்த நேரத்திலும் துவக்கப்படலாம்.

carName = "Volvo";
var carName; // ✅ Allowed (hoisted)

const உடன் வரையறுக்கப்பட்ட மாறிகள் மேலே hoist செய்யப்படுகின்றன, ஆனால் துவக்கப்படவில்லை.

alert(carName);    // ❌ ReferenceError
const carName = "Volvo";

Exercise